package ongd.web;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import ongd.negocio.gestion.Apadrinado;
import ongd.negocio.gestion.ControladorApadrinamiento;
import ongd.negocio.gestion.ControladorPadrino;
import ongd.negocio.gestion.ControladorSocio;
import ongd.negocio.gestion.Fraccionado;
import ongd.negocio.gestion.Persona;
import ongd.negocio.gestion.Proyecto;
import ongd.servicios.persistencia.exceptions.IllegalOrphanException;
import ongd.servicios.persistencia.exceptions.NonexistentEntityException;
import org.primefaces.context.RequestContext;

/**
 * Clase que se encargará de listar los socios o padrinos dados de alta.
 *
 * @author <a href="mailto:egi0002@alu.ubu.es">Elena García Iglesias</a>
 * @author <a href="mailto:cms0021@alu.ubu.es">Cristina Martínez Sanz</a>
 * @version 1.0 20120124
 *
 */
@ManagedBean
@ViewScoped
public class Listado_Persona extends ABean {

    /**
     * Objeto del tipo ControladorSocio que nos servirá para realizar todas las 
     * operaciones referentes a los socios.
     */
    private ControladorSocio contSocio;
    /**
     * Objeto del tipo ControladorPadrino que nos servirá para realizar todas
     * las operaciones referentes a los padrinos.
     */
    private ControladorPadrino contPadrino;
    /**
     * Objeto del tipo Controlador Apadrinamiento que nos servirá para realizar
     * todas las operaciones de referentes al apadrinamiento que tengan 
     * los padrinos con los proyectos y apadrinados.
     */
    private ControladorApadrinamiento contApadrinamiento;
    /**
     * Objeto del tipo Persona que va a contener los datos del socio o padrino.
     */
    private Persona persona;
    /**
     * Objeto del tipo Fraccionado que va a contener el fraccionado seleccionado
     * del socio o padrino.
     */
    private Fraccionado fraccionado;
    /**
     * Objeto del tipo Proyecto que va a contener el proyecto seleccionado
     * del socio o padrino.
     */
    private Proyecto proyecto;
    /**
     * Objeto del tipo Apadrinado que va a contener el apadrinado del socio
     * o padrino.
     */
    private Apadrinado apadrinado;
    /**
     * Objeto de tipo List que va a contener una lista de personas que 
     * corresponderá a los socios o padrinos que estén dados de alta en la
     * base de datos.
     */
    private List<Persona> vctPersonas;
    /**
     * Objeto de tipo List que va a contener una lista de fraccionados que 
     * corresponderán con los fraccionados relacionados con el socio o padrino
     * seleccionado.
     */
    private List<Fraccionado> listaFraccionado;
    /**
     * Objeto de tipo List que va a contener una lista de proyectos que
     * corresponderán con los proyectos que apadrina el padrino seleccionado.
     */
    private List<Proyecto> proyectosPadrino;
    /**
     * Objeto de tipo List que va a contener una lista de apadrinados que 
     * corresponderá con los apadrinados que están relacionados con el 
     * padrino seleccionado.
     */
    private List<Apadrinado> apadrinadosPadrino;
    /**
     * Objeto de tipo List que va a contener una lista de apadrinados que 
     * corresponderá con los apadrinados que están disponibles para que el 
     * padrino los apadrine.
     */
    private List<Apadrinado> apadrinadoD;
    /**
     * Objeto de tipo List que va a contener una lista de apadrinados que
     * coincidan en proyecto y padrino.
     */
    private List<Apadrinado> apadrinadoProyectoPadrino;
    /**
     * Objeto de tipo List que va a contener una lista de apadrinados que
     * corresponderá con los apadrinados de un mismo proyecto que el padrino 
     * a eliminado, servíra para poder volver a elegirlo.
     */
    private List<Apadrinado> apadrinadoBorradoDisponible;
    /**
     * Booleano que dependiendo de su valor permitirá editar o no un padrino
     * o socio.
     */
    private boolean editar;
    /**
     * Booleano que dependiendo de su valor permitirá añadir o editar un
     * objeto de tipo fraccionado.
     */
    private boolean annadirF;
    /**
     * Booleano que dependiendo de su valor nos indicará que debemos de llamar
     * a un método u otro.
     */
    private boolean annadirA;
    /**
     * Booleano qeu dependiendo de su valor nos permitirá acceder a unos
     * botones u otros.
     */
    private boolean apadrinamiento;
    /**
     * Booleano que dependiendo de su valor nos indica si hemos modificado
     * el pago fraccionado.
     */
    private boolean fraccionadoModificada;
    /**
     * Booleano que dependiendo de su valor nos indica si hemos modificado
     * lo relativo al apadrinamiento de un padrino o no.
     */
    private boolean apadrinamientoModificado;
    /**
     * Objeto de tioi String que corresponderá al mes en el caso de modificar
     * el pago fraccionado de un socio o padrino.
     */
    private String mes;
    /**
     * Objeto de tipo String que corresponderá al nombre de proyecto en el caso
     * de añadir un nuevo proyecto a los apadrinamientos del padrino.
     */
    private String proyectoNombre;
    /**
     * Objeto de tipo double que va a contener la cantidad del socio o padrino 
     * seleccionado.
     */
    private double cantidad;
    /**
     * Objeto de tipo String que va a contener el título de la página donde
     * estemos.
     */
    private String titulo;

    /**
     * Constructor de la clase.
     */
    public Listado_Persona() {
        persona = new Persona();
        vctPersonas = new ArrayList<Persona>();
        fraccionado = new Fraccionado();
        listaFraccionado = new ArrayList<Fraccionado>();
        apadrinadoProyectoPadrino = new ArrayList<Apadrinado>();
        apadrinadoBorradoDisponible = new ArrayList<Apadrinado>();
        apadrinado = new Apadrinado();
        annadirF = false;
        annadirA = false;
        apadrinamiento = false;
        fraccionadoModificada = false;
        apadrinamientoModificado = false;
    }

    /**
     * Método abstracto que se encargará de cargar los parámetros iniciales.
     */
    @Override
    public void cargaInicial() {
        if (!FacesContext.getCurrentInstance().isPostback()) {
            SesionBean sesion = getSesionBean();
            if (sesion.iniciadaSesion()) {
                if (sesion.getStrVariable().compareTo("socio") == 0) {
                    titulo = "Gestionar - Socio";
                    contSocio = sesion.getControladorSocio();
                    persona.setTipo("S");
                    vctPersonas = contSocio.obtenerListaPersonaAlta("S");
                    apadrinamiento = false;
                } else if (sesion.getStrVariable().compareTo("padrino") == 0) {
                    titulo = "Gestionar - Padrino";
                    contPadrino = sesion.getControladorPadrino();
                    contApadrinamiento = sesion.getControladorApadrinamiento();
                    persona.setTipo("P");
                    vctPersonas = contPadrino.obtenerListaPersonaAlta("P");
                    apadrinamiento = true;
                }
            }
        }
    }

    /**
     * Método que edita un socio o padrino según lo que el cliente desee.
     * En caso de que la lista de fraccionados sea vacia, mostrará un
     * mensaje de error para indicarlo.
     * @return null
     */
    public String aceptar() {
        if (getSesionBean().iniciadaSesion()) {
            try {
                RequestContext requestContext = RequestContext.getCurrentInstance();
                if (editar) {
                    if (comprobarCampos()) {
                        editarPersona();
                        requestContext.addCallbackParam("todoOK", true);
                    }
                } else {
                    requestContext.addCallbackParam("consultar", true);
                }
            } catch (IllegalOrphanException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NonexistentEntityException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (Exception ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }

    /**
     * Método que comprobará que los campos introducidos son correctos y
     * no falta ninguno.
     * @return true o false en función de si faltan datos o no
     */
    public boolean comprobarCampos() {
        boolean correcto = true;
        RequestContext requestContext = RequestContext.getCurrentInstance();
        if (persona.getNombre().compareTo("") == 0 || persona.getApellidos().compareTo("") == 0 || persona.getFechaNacimiento() == null) {//            
            requestContext.addCallbackParam("noDatos", true);
            correcto = false;//                
        } else if (persona.getCantidad() == 0) {
            requestContext.addCallbackParam("noCantidad", true);
            correcto = false;
        } else if (persona.getDomiciliacion() && persona.getNCuenta().compareTo("") == 0) {
            requestContext.addCallbackParam("noNCuenta", true);
            correcto = false;
        } else if (listaFraccionado.isEmpty()) {
            requestContext.addCallbackParam("noFraccionado", true);
            correcto = false;
        }
        return correcto;
    }

    /**
     * Método que edita las fracciones de un socio o padrino.
     * @return null
     */
    public String editarFraccionado() {
        /* Recorreré la lista para saber si ya existe ese mes, pues si es asi 
         * el booleano será verdadero y el mes no va a cambiar. */
        boolean repetido = false;
        for (Fraccionado f : listaFraccionado) {
            if ((f.getMes().compareTo(mes) == 0) || repetido == true) {
                repetido = true;
            }
        }
        //Si no hay meses repetidos meto el mes en la lista.
        if (!repetido) {
            fraccionado.setMes(mes);
            if (annadirF) {
                listaFraccionado.add(fraccionado);
            }
        }
        fraccionado = new Fraccionado();
        mes = new String();
        fraccionadoModificada = true;
        return null;
    }

    /**
     * Método que borrar un fraccionado de la lista de fracciones del socio o 
     * padrino.
     * @return null
     */
    public String borrarFraccionado() {
        //Elimino esa fraccion de la lista        
        listaFraccionado.remove(fraccionado);
        fraccionadoModificada = true;
        return null;
    }

    /**
     * Método que obtiene los apadrinados correspondientes a un padrino.
     * @return null
     */
    public String obtenerApadrinados() {
        apadrinadoProyectoPadrino = new ArrayList<Apadrinado>();
        //Recorreré las dos listas de proyectos y apadrinados en los que participa el proyecto e iré comparando
        for (int i = 0; i < proyectosPadrino.size(); i++) {
            Proyecto p = proyectosPadrino.get(i);
            for (int j = 0; j < apadrinadosPadrino.size(); j++) {
                Apadrinado a = apadrinadosPadrino.get(j);
                if (p.esProyectoApadrinamientoPersonal()) {
                    if (a.getProyecto().getIdProyecto().compareTo(p.getIdProyecto()) == 0) {
                        apadrinadoProyectoPadrino.add(a);
                    }
                }
            }
        }
        return null;
    }

    /**
     * Método que se ejecutará cuando queramos añadir un nuevo apadrinado, 
     * servirá para obtener los apadrinados disponibles.
     * @return null
     */
    public String nuevoApadrinado() {
        apadrinadoD = new ArrayList<Apadrinado>();
        apadrinadoD = obtenerApadrinadosDisponibles(apadrinadoBorradoDisponible);
        return null;
    }

    /**
     * Método que quita un proyecto de la lista de proyectos del padrino, si
     * el proyecto es de apadrinamiento personal quitará los apadrinados 
     * el padrino que correspondan con ese proyecto.
     * @return null
     */
    public String quitarProyecto() {
        //Quito el proyecto de la lista
        proyectosPadrino.remove(proyecto);
        //Si el proyecto es de apadrinamiento personal buscaré los padrinos que estaba apadrinando y los quitaré de la lista
        if (proyecto.esProyectoApadrinamientoPersonal()) {
            for (int i = apadrinadosPadrino.size() - 1; i >= 0; i--) {
                Apadrinado a = apadrinadosPadrino.get(i);
                if (a.getProyecto().equals(proyecto)) {
                    apadrinadosPadrino.remove(a);
                }
            }
        }
        //Modifico el booleano a true para indicar que se ha modificado el apadrinamiento
        apadrinamientoModificado = true;
        //Inicializo la variable
        proyecto = new Proyecto();
        return null;
    }

    /**
     * Método que quita el apadrinado seleccionado de la lista de apadrinados
     * del padrino, además guardará dicho apadrinado en otra lista que permitirá
     * poder volver a seleccionar el apadrinado eliminado.
     * @return null
     */
    public String quitarApadrinado() {
        apadrinadosPadrino.remove(apadrinado);
        apadrinadoBorradoDisponible.add(apadrinado);
        apadrinamientoModificado = true;
        obtenerApadrinados();
        //Inicializo la variable
        apadrinado = new Apadrinado();
        return null;
    }

    /**
     * Método que devuelve una lista de String con el nombre de cada proyecto
     * de tipo apadrinamiento general o personal que existe en la base de datos.
     * @return availableP
     */
    public List<String> getAvailableP() {
        if (contApadrinamiento != null) {
            List<String> availableP = new ArrayList<String>();
            for (Proyecto p : contApadrinamiento.obtenerProyectosApadrinamientoDisponibles()) {
                String cadena = p.getNombre();
                availableP.add(cadena);
            }
            return availableP;
        }
        return null;
    }

    /**
     * Método que se ejecutará cuando añadimos un nuevo proyecto y elegimos 
     * el que queremos apadrinadar. Si el proyecto es del tipo apadrinamiento
     * personal, entonces obtendrá los apadrinamientos disponibles y nos 
     * enviará a otro dialogo que permitirá elegir el apadrinado que queremos.
     * @return null
     */
    public String aceptarProyecto() {
        RequestContext requestContext = RequestContext.getCurrentInstance();
        proyecto = contApadrinamiento.buscarProyecto(proyectoNombre);
        //miraré si el proyecto ya esta siendo apadrinado por el padrino
        boolean repetido = false;
        for (Proyecto m : proyectosPadrino) {
            if (m.equals(proyecto) && repetido == false) {
                repetido = true;
            }
        }
        //Si no esta repetido
        if (!repetido) {
            if (proyecto.esProyectoApadrinamientoPersonal()) {
                apadrinadoD = obtenerApadrinadosDisponibles(null);
                requestContext.addCallbackParam("annadirApadrinado", true);
                annadirA = true;
            } else if (proyecto.esProyectoApadrinamientoGeneral()) {
                annadirProyecto();
            }
        } else {
            //Si hay un proyecto ya repetido saco un mensaje de error
            requestContext.addCallbackParam("proyectoRepetido", true);
        }
        return null;
    }

    /**
     * Método que devuelve una lista con los apadrinados que hay disponibles
     * para que el padrino los pueda seleccionar, si la lista pasada por 
     * parámetro no es nula, añadirá los apadrinados que contiene a la lista
     * que devolverá.
     * @param lista Lista de apadrinados
     * @return lita de apadrinados
     */
    public List<Apadrinado> obtenerApadrinadosDisponibles(List<Apadrinado> lista) {
        List<Apadrinado> listaA = new ArrayList<Apadrinado>();
        boolean repetido;
        for (Apadrinado a : contApadrinamiento.obtenerApadrinadosDisponibles(proyecto)) {
            repetido = false;
            for (Apadrinado a2 : apadrinadosPadrino) {
                if (a.getApadrinadoPK().equals(a2.getApadrinadoPK()) && repetido == false) {
                    repetido = true;
                }
            }
            if (!repetido) {
                listaA.add(a);
            }
        }

        if (lista != null) {
            if (!lista.isEmpty()) {
                for (Apadrinado a : lista) {
                    listaA.add(a);
                }
            }
        }
        return listaA;
    }

    /**
     * Método que comprobará si la lista de apadrinados de un proyecto con un
     * padrino es vacia, pues si lo es saltará un mensaje de error.
     * @return null
     */
    public String aceptarApadrinado() {
        RequestContext requestContext = RequestContext.getCurrentInstance();
        //Si es verdadero implica que estamos llamando el metodo desde añadir nuevo proyecto
        if (annadirA) {
            annadirProyecto();
        } else {
            //referente a la otra opcion
            annadirApadrinado();
            requestContext.addCallbackParam("apadrinadoOK", true);
        }
        annadirA = false;
        return null;
    }

    /**
     * Método que añade un proyecto a la lista de proyectos del padrino,
     * si el proyecto es de tipo apadrinamiento personal y el apadirnado es
     * nulo saltará un mensaje de error.
     */
    public void annadirProyecto() {
        RequestContext requestContext = RequestContext.getCurrentInstance();
        if (proyecto.esProyectoApadrinamientoPersonal()) {
            if (apadrinado == null) {
                // Si llego hasta aqui es que no se ha seleccionado un apadrinado
                requestContext.addCallbackParam("errorApadrinado", true);
            } else {
                annadirApadrinado();
            }
        }
        requestContext.addCallbackParam("proyectoAnnadidoOK", true);
        //Sea el proyecto de un tipo u otro, le añado a la lista de proyectos del padrino
        proyectosPadrino.add(proyecto);
        apadrinamientoModificado = true;
        //Inicializo las variables
        proyectoNombre = new String();
        proyecto = new Proyecto();
    }

    /**
     * Método que añade un apadrinado a la lista de apadrinados del padrino.
     */
    public void annadirApadrinado() {
        apadrinadosPadrino.add(apadrinado);
        apadrinamientoModificado = true;
        obtenerApadrinados();
        apadrinado = new Apadrinado();
    }

    /**
     * Método que comprueba si la lista de proyectos de un padrino esta vacia, 
     * pues si es asi, lanzará un mensaje de error, porque un padrino
     * tiene que apadrinar al menos un proyecto.
     * @return null
     */
    public String aceptarListaProyectos() {
        RequestContext requestContext = RequestContext.getCurrentInstance();
        if (proyectosPadrino.isEmpty()) {
            requestContext.addCallbackParam("noProyectos", true);
        } else {
            requestContext.addCallbackParam("proyectosBien", true);
        }
        return null;
    }

    /**
     * Método que comprueba si la lista de apadrinados que relacionan un proyecto
     * con un padrino esta vacia, pues si es asi, lanzará un mensaja de error.
     * @return null
     */
    public String aceptarListaApadrinados() {
        apadrinadoBorradoDisponible = new ArrayList<Apadrinado>();
        RequestContext requestContext = RequestContext.getCurrentInstance();
        if (apadrinadoProyectoPadrino.isEmpty()) {
            requestContext.addCallbackParam("noApadrinado", true);
        } else {
            requestContext.addCallbackParam("apadrinadoBien", true);
        }
        return null;
    }

    /**
     * Método que modifica los datos de un socio o padrino en funcion de lo
     * que se haya modificado.
     * @throws IllegalOrphanException
     * @throws NonexistentEntityException será lanzada si no exisite el socio o 
     * padrino a modificar.
     * @throws Exception
     */
    public void editarPersona() throws IllegalOrphanException, NonexistentEntityException, Exception {
        boolean cantidadM = false;
        //Si la cantidad no es igual, modificaré las cuotas
        if (cantidad != persona.getCantidad()) {
            cantidadM = true;
        }
        if (contSocio != null) {
            if (fraccionadoModificada) {
                contSocio.editarSocio(persona, listaFraccionado);
            } else {
                if (cantidadM) {
                    contSocio.editarSocio(persona, listaFraccionado);
                } else {
                    contSocio.editarSocio(persona, null);
                }
            }
        } else if (contPadrino != null) {
            if (fraccionadoModificada && apadrinamientoModificado) {
                //Si se ha modificado el pago fraccionado y el apadrinamiento
                contPadrino.editarPadrino(persona, listaFraccionado, proyectosPadrino, apadrinadosPadrino);
            } else if (fraccionadoModificada && !apadrinamientoModificado) {
                //Si se ha modificado el pago fraccionado pero no el apadrinamiento
                contPadrino.editarPadrino(persona, listaFraccionado, null, null);
            } else if (!fraccionadoModificada && apadrinamientoModificado) {
                //Si no se ha modificado el pago fraccionado pero si el apadrinamiento 
                if (cantidadM) {
                    contPadrino.editarPadrino(persona, listaFraccionado, proyectosPadrino, apadrinadosPadrino);
                } else {
                    contPadrino.editarPadrino(persona, null, proyectosPadrino, apadrinadosPadrino);
                }
            } else if (!fraccionadoModificada && !apadrinamientoModificado) {
                //Si no se han modificado ninguna de las dos cosas
                if (cantidadM) {
                    contPadrino.editarPadrino(persona, listaFraccionado, null, null);
                } else {
                    contPadrino.editarPadrino(persona, null, null, null);
                }
            }
        }
        fraccionadoModificada = false;
        apadrinamientoModificado = false;
        listaFraccionado = new ArrayList<Fraccionado>();
        proyectosPadrino = new ArrayList<Proyecto>();
        apadrinadosPadrino = new ArrayList<Apadrinado>();
    }

    /**
     * Método que borra un socio o padrino.
     * @return null
     */
    public String borrarPersona() {
        if (getSesionBean().iniciadaSesion()) {
            RequestContext requestContext = RequestContext.getCurrentInstance();
            try {
                boolean borrada = false;
                if (contSocio != null) {
                    borrada = contSocio.borrarPersona(persona);
                    vctPersonas = contSocio.obtenerListaPersonaAlta("S");
                } else if (contPadrino != null) {
                    borrada = contPadrino.borrarPersona(persona);
                    vctPersonas = contPadrino.obtenerListaPersonaAlta("P");
                }
                if (borrada) {
                    //Si llegamos hasta aqui es que el socio o padrino se ha borrado correctamente                
                    requestContext.addCallbackParam("borradoOK", true);
                } else {
                    requestContext.addCallbackParam("noBorrado", true);
                }
                borrada = false;
            } catch (IllegalOrphanException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NonexistentEntityException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (Exception ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }

    /**
     * Método que da de baja un socio o padrino.
     * @return null
     */
    public String darBajaPersona() {
        if (getSesionBean().iniciadaSesion()) {
            RequestContext requestContext = RequestContext.getCurrentInstance();
            try {
                if (contSocio != null) {
                    contSocio.darBajaPersona(persona);
                    vctPersonas = contSocio.obtenerListaPersonaAlta("S");
                } else if (contPadrino != null) {
                    contPadrino.darBajaPersona(persona);
                    vctPersonas = contPadrino.obtenerListaPersonaAlta("P");
                }
                //Si llego aqui es que el socio se ha dado de baja correctamente.
                requestContext.addCallbackParam("bajaOK", true);
            } catch (IllegalOrphanException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NonexistentEntityException ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            } catch (Exception ex) {
                Logger.getLogger(Listado_Persona.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }

    /**
     * Método que pone la variable adecuada para añadir una nueva fraccion
     * al padrino o socio.
     * @return null
     */
    public String annadirF() {
        annadirF = true;
        return null;
    }

    /**
     * Método que pone la variable adecuada para añadir una nueva fracción al
     * padrino o socio.
     * @return null
     */
    public String editarF() {
        annadirF = false;
        return null;
    }

    /**
     * Método que pone las variables adecuadas para consultar los datos del 
     * padrino o socio.
     * @return null
     */
    public String consultar() {
        editar = false;
        listaFraccionado = new ArrayList<Fraccionado>();
        listaFraccionado.addAll(persona.getFraccionadoList());
        if (persona.esPadrino()) {
            proyectosPadrino = new ArrayList<Proyecto>();
            apadrinadosPadrino = new ArrayList<Apadrinado>();
            proyectosPadrino.addAll(persona.getProyectoList());
            apadrinadosPadrino.addAll(persona.getApadrinadoList());
        }
        return null;
    }

    /**
     * Método que pone las variables adecuadas para modificar los datos del socio.
     * @return null
     */
    public String editar() {
        editar = true;
        listaFraccionado = new ArrayList<Fraccionado>();
        listaFraccionado.addAll(persona.getFraccionadoList());
        cantidad = persona.getCantidad();
        if (persona.esPadrino()) {
            proyectosPadrino = new ArrayList<Proyecto>();
            apadrinadosPadrino = new ArrayList<Apadrinado>();
            proyectosPadrino.addAll(persona.getProyectoList());
            apadrinadosPadrino.addAll(persona.getApadrinadoList());
            apadrinadoD = new ArrayList<Apadrinado>();
        }
        return null;
    }

    /**
     * Método que devuelve el valor de la variable editar.
     * @return true si la variable es verdadera
     *         false si la variable es falsa
     */
    public boolean isEditar() {
        return editar;
    }

    /**
     * Método que asigna un valor a la variable editar.
     * @param editar valor que vamos a asignar.
     */
    public void setEditar(boolean editar) {
        this.editar = editar;
    }

    /**
     * Método que devuelve el valor de la variable apadrinadoBorradoDisponible.
     * @return apadrinadoBorradoDisponible
     * @see #setApadrinadoBorradoDisponible
     */
    public List<Apadrinado> getApadrinadoBorradoDisponible() {
        return apadrinadoBorradoDisponible;
    }

    /**
     * Método que establece un valor a la variable ApadrinadoBorradoDisponible.
     * @param apadrinadoBorradoDisponible Nuevo valor de la variable
     * @see #getApadrinadoBorradoDisponible
     */
    public void setApadrinadoBorradoDisponible(List<Apadrinado> apadrinadoBorradoDisponible) {
        this.apadrinadoBorradoDisponible = apadrinadoBorradoDisponible;
    }

    /**
     * Método que devuelve el valor de la variable ApadrinamientoModificado.
     * @return apadrinamientoModificado
     */
    public boolean isApadrinamientoModificado() {
        return apadrinamientoModificado;
    }

    /**
     * Método que establece un valor a la variable ApadrinamientoModificado.
     * @param apadrinamientoModificado Nuevo valor de la variable
     */
    public void setApadrinamientoModificado(boolean apadrinamientoModificado) {
        this.apadrinamientoModificado = apadrinamientoModificado;
    }

    /**
     * Método que devuelve el valor de la variable AñadirA.
     * @return añadirA
     */
    public boolean isAnnadirA() {
        return annadirA;
    }

    /**
     * Método que establece un valor a la variable añadirA.
     * @param annadirA Nuevo valor de la variable
     */
    public void setAnnadirA(boolean annadirA) {
        this.annadirA = annadirA;
    }

    /**
     * Método que devuelve el valor de la variable añadirF.
     * @return añadirF
     */
    public boolean isAnnadirF() {
        return annadirF;
    }

    /**
     * Método que establece un valor a la variable añadirF.
     * @param annadirF Nuevo valor de la variable
     */
    public void setAnnadirF(boolean annadirF) {
        this.annadirF = annadirF;
    }

    /**
     * Método que devuelve un objeto de tipo ControladorApadrinamiento.
     * @return contApadrinamiento
     * @see #setContApadrinamiento
     */
    public ControladorApadrinamiento getContApadrinamiento() {
        return contApadrinamiento;
    }

    /**
     * Método que establece un objeto del tipo Controlador Apadrinamiento.
     * @param contApadrinamiento Nuevo valor de la variable
     * @see #getContApadrinamiento
     */
    public void setContApadrinamiento(ControladorApadrinamiento contApadrinamiento) {
        this.contApadrinamiento = contApadrinamiento;
    }

    /**
     * Método que devuelve un objeto del tipo ControladorPadrino.
     * @return contPadrino
     * @see #setContPadrino
     */
    public ControladorPadrino getContPadrino() {
        return contPadrino;
    }

    /**
     * Método que establece un objeto del tipo ControladorPadrino.
     * @param contPadrino Nuevo valor de la variable
     * @see #getContPadrino
     */
    public void setContPadrino(ControladorPadrino contPadrino) {
        this.contPadrino = contPadrino;
    }

    /**
     * Método que devuelve un objeto del tipo ControladorSocio.
     * @return contSocio Nuevo valor de la variable
     * @see #setContSocio
     */
    public ControladorSocio getContSocio() {
        return contSocio;
    }

    /**
     * Método que establece un objeto del tipo ControladorSocio.
     * @param contSocio Nuevo valor de la variable
     * @see #getContSocio
     */
    public void setContSocio(ControladorSocio contSocio) {
        this.contSocio = contSocio;
    }

    /**
     * Método que devuelve el valor de la variable fraccionadoModificada. 
     * @return fraccionadoModificada
     */
    public boolean isFraccionadoModificada() {
        return fraccionadoModificada;
    }

    /**
     * Método que establece el valor de la variable fraccionadoModficada.
     * @param fraccionadoModificada Nuevo valor de la variable
     */
    public void setFraccionadoModificada(boolean fraccionadoModificada) {
        this.fraccionadoModificada = fraccionadoModificada;
    }

    /**
     * Metodo que devuelve el valor de la variable persona.
     * @return persona
     * @see #setPersona
     */
    public Persona getPersona() {
        return persona;
    }

    /**
     * Método que establece el valor de la variable persona.
     * @param persona Nuevo valor de la variable
     * @see #getPersona
     */
    public void setPersona(Persona persona) {
        this.persona = persona;
    }

    /**
     * Método que devuelve el valor de la variable vctPersonas.
     * @return vctPersonas
     * @see #setVctPersonas
     */
    public List<Persona> getVctPersonas() {
        return vctPersonas;
    }

    /**
     * Método que establece el valor de la variable vctPersonas.
     * @param vctPersonas Nuevo valor de la variable
     * @see #getVctPersonas
     */
    public void setVctPersonas(List<Persona> vctPersonas) {
        this.vctPersonas = vctPersonas;
    }

    /**
     * Método que devuelve el valor de la variable fraccionado.
     * @return fraccionado
     * @see #setFraccionado
     */
    public Fraccionado getFraccionado() {
        return fraccionado;
    }

    /**
     * Método que establece el valor de la variable fraccionado.
     * @param fraccionado Nuevo valor de la variable
     * @see #getFraccionado
     */
    public void setFraccionado(Fraccionado fraccionado) {
        this.fraccionado = fraccionado;
    }

    /**
     * Método que devuelve el valro de la variable mes.
     * @return mes
     * @see #setMes
     */
    public String getMes() {
        return mes;
    }

    /**
     * Método que establece el valor de la variable mes.
     * @param mes Nuevo valor de la variable
     * @see #getMes
     */
    public void setMes(String mes) {
        this.mes = mes;
    }

    /**
     * Método que devuelve el valor de la listaFraccionado.
     * @return listaFraccionado
     * @see #setListaFraccionado
     */
    public List<Fraccionado> getListaFraccionado() {
        return listaFraccionado;
    }

    /**
     * Método que establece el valor de la variable listaFraccionado.
     * @param listaFraccionado Nuevo valor de la variable
     * @see #getListaFraccionado
     */
    public void setListaFraccionado(List<Fraccionado> listaFraccionado) {
        this.listaFraccionado = listaFraccionado;
    }

    /**
     * Método que devuelve el valor de la variable apadrinamiento.
     * @return apadrinamiento
     */
    public boolean isApadrinamiento() {
        return apadrinamiento;
    }

    /**
     * Método que establece el valor de la variable apadrinamiento.
     * @param apadrinamiento Nuevo valor de la variable
     */
    public void setApadrinamiento(boolean apadrinamiento) {
        this.apadrinamiento = apadrinamiento;
    }

    /**
     * Método devuelve el valor de la variable apadrinadosPadrino.
     * @return apadrinadosPadrino
     * @see #setApadrinadosPadrino
     */
    public List<Apadrinado> getApadrinadosPadrino() {
        return apadrinadosPadrino;
    }

    /**
     * Método que establece el valor de la variable apadrinadosPadrino.
     * @param apadrinadosPadrino Nuevo valor de la variable
     * @see #getApadrinadosPadrino
     */
    public void setApadrinadosPadrino(List<Apadrinado> apadrinadosPadrino) {
        this.apadrinadosPadrino = apadrinadosPadrino;
    }

    /**
     * Método que devuelve el valor de la variable ProyectosPadrino.
     * @return proyectosPadrino
     * @see #setProyectosPadrino
     */
    public List<Proyecto> getProyectosPadrino() {
        return proyectosPadrino;
    }

    /**
     * Método que establece el valor de la variable proyectosPadrino.
     * @param proyectosPadrino Nuevo valor de la variable
     * @see #getProyectosPadrino
     */
    public void setProyectosPadrino(List<Proyecto> proyectosPadrino) {
        this.proyectosPadrino = proyectosPadrino;
    }

    /**
     * Método que devuelve el valor de la variable proyecto.
     * @return proyecto
     * @see #setProyecto
     */
    public Proyecto getProyecto() {
        return proyecto;
    }

    /**
     * Método que establece el valor  de la variable proyecto.
     * @param proyecto Nuevo valor de la variable
     * @see #getProyecto
     */
    public void setProyecto(Proyecto proyecto) {
        this.proyecto = proyecto;
    }

    /**
     * Método que devuelve el valor de la variable proyectoNombre.
     * @return proyectoNombre
     * @see #setProyectoNombre
     */
    public String getProyectoNombre() {
        return proyectoNombre;
    }

    /**
     * Método que establece el valor de la variable proyectoNombre.
     * @param proyectoNombre Nuevo valor de la variable
     * @see #getProyectoNombre
     */
    public void setProyectoNombre(String proyectoNombre) {
        this.proyectoNombre = proyectoNombre;
    }

    /**
     * Método que devuelve el valor de la variable apadrinado.
     * @return apadrinado
     * @see #setApadrinado
     */
    public Apadrinado getApadrinado() {
        return apadrinado;
    }

    /**
     * Método que establece el valor de la variable apadrinado.
     * @param apadrinado Nuevo valor de la variable
     * @see #getApadrinado
     */
    public void setApadrinado(Apadrinado apadrinado) {
        this.apadrinado = apadrinado;
    }

    /**
     * Método que devuelve el valor de la variable apadriandoD.
     * @return apadriandoD
     * @see #setApadrinadoD
     */
    public List<Apadrinado> getApadrinadoD() {
        return apadrinadoD;
    }

    /**
     * Metodo que establece el valor de la variable apadrinadoD.
     * @param apadrinadoD Nuevo valor de la variable
     * @see #getApadrinadoD
     */
    public void setApadrinadoD(List<Apadrinado> apadrinadoD) {
        this.apadrinadoD = apadrinadoD;
    }

    /**
     * Método que devuelve el valor de la variable apadrinadoProyectoPadrino.
     * @return apadrinadoProyectoPadrino
     * @see #setApadrinadoProyectoPadrino
     */
    public List<Apadrinado> getApadrinadoProyectoPadrino() {
        return apadrinadoProyectoPadrino;
    }

    /**
     * Método que establece el valor de la variable apadriandoProyectoPadrino.
     * @param apadrinadoProyectoPadrino Nuevo valor de la variable
     * @see #getApadrinadoProyectoPadrino
     */
    public void setApadrinadoProyectoPadrino(List<Apadrinado> apadrinadoProyectoPadrino) {
        this.apadrinadoProyectoPadrino = apadrinadoProyectoPadrino;
    }

    /**
     * Método que devuelve el valor de la variable titulo.
     * @return titulo
     * @see #setTitulo
     */
    public String getTitulo() {
        return titulo;
    }

    /**
     * Método que establece el valor de la variable título.
     * @param titulo Nuevo valor de la variable
     * @see #getTitulo
     */
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
}
